--- videodev2.h.orig	Thu Mar 25 00:43:05 2010
+++ videodev2.h	Fri Apr  9 13:57:39 2010
@@ -58,8 +58,8 @@
 
 #include <sys/time.h>
 
-#include <linux/ioctl.h>
-#include <linux/types.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
 
 /*
  * Common stuff for both V4L1 and V4L2
@@ -92,7 +92,7 @@
 
 /*  Four-character-code (FOURCC) */
 #define v4l2_fourcc(a, b, c, d)\
-	((__u32)(a) | ((__u32)(b) << 8) | ((__u32)(c) << 16) | ((__u32)(d) << 24))
+	((uint32_t)(a) | ((uint32_t)(b) << 8) | ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24))
 
 /*
  *	E N U M S
@@ -212,27 +212,27 @@ enum v4l2_priority {
 };
 
 struct v4l2_rect {
-	__s32   left;
-	__s32   top;
-	__s32   width;
-	__s32   height;
+	int32_t   left;
+	int32_t   top;
+	int32_t   width;
+	int32_t   height;
 };
 
 struct v4l2_fract {
-	__u32   numerator;
-	__u32   denominator;
+	uint32_t   numerator;
+	uint32_t   denominator;
 };
 
 /*
  *	D R I V E R   C A P A B I L I T I E S
  */
 struct v4l2_capability {
-	__u8	driver[16];	/* i.e. "bttv" */
-	__u8	card[32];	/* i.e. "Hauppauge WinTV" */
-	__u8	bus_info[32];	/* "PCI:" + pci_name(pci_dev) */
-	__u32   version;        /* should use KERNEL_VERSION() */
-	__u32	capabilities;	/* Device capabilities */
-	__u32	reserved[4];
+	uint8_t	driver[16];	/* i.e. "bttv" */
+	uint8_t	card[32];	/* i.e. "Hauppauge WinTV" */
+	uint8_t	bus_info[32];	/* "PCI:" + pci_name(pci_dev) */
+	uint32_t   version;        /* should use KERNEL_VERSION() */
+	uint32_t	capabilities;	/* Device capabilities */
+	uint32_t	reserved[4];
 };
 
 /* Values for 'capabilities' field */
@@ -259,14 +259,14 @@ struct v4l2_capability {
  *	V I D E O   I M A G E   F O R M A T
  */
 struct v4l2_pix_format {
-	__u32         		width;
-	__u32			height;
-	__u32			pixelformat;
+	uint32_t         		width;
+	uint32_t			height;
+	uint32_t			pixelformat;
 	enum v4l2_field  	field;
-	__u32            	bytesperline;	/* for padding, zero if unused */
-	__u32          		sizeimage;
+	uint32_t            	bytesperline;	/* for padding, zero if unused */
+	uint32_t          		sizeimage;
 	enum v4l2_colorspace	colorspace;
-	__u32			priv;		/* private data, depends on pixelformat */
+	uint32_t			priv;		/* private data, depends on pixelformat */
 };
 
 /*      Pixel format         FOURCC                        depth  Description  */
@@ -352,12 +352,12 @@ struct v4l2_pix_format {
  *	F O R M A T   E N U M E R A T I O N
  */
 struct v4l2_fmtdesc {
-	__u32		    index;             /* Format number      */
+	uint32_t		    index;             /* Format number      */
 	enum v4l2_buf_type  type;              /* buffer type        */
-	__u32               flags;
-	__u8		    description[32];   /* Description string */
-	__u32		    pixelformat;       /* Format fourcc      */
-	__u32		    reserved[4];
+	uint32_t               flags;
+	uint8_t		    description[32];   /* Description string */
+	uint32_t		    pixelformat;       /* Format fourcc      */
+	uint32_t		    reserved[4];
 };
 
 #define V4L2_FMT_FLAG_COMPRESSED 0x0001
@@ -374,30 +374,30 @@ enum v4l2_frmsizetypes {
 };
 
 struct v4l2_frmsize_discrete {
-	__u32			width;		/* Frame width [pixel] */
-	__u32			height;		/* Frame height [pixel] */
+	uint32_t			width;		/* Frame width [pixel] */
+	uint32_t			height;		/* Frame height [pixel] */
 };
 
 struct v4l2_frmsize_stepwise {
-	__u32			min_width;	/* Minimum frame width [pixel] */
-	__u32			max_width;	/* Maximum frame width [pixel] */
-	__u32			step_width;	/* Frame width step size [pixel] */
-	__u32			min_height;	/* Minimum frame height [pixel] */
-	__u32			max_height;	/* Maximum frame height [pixel] */
-	__u32			step_height;	/* Frame height step size [pixel] */
+	uint32_t			min_width;	/* Minimum frame width [pixel] */
+	uint32_t			max_width;	/* Maximum frame width [pixel] */
+	uint32_t			step_width;	/* Frame width step size [pixel] */
+	uint32_t			min_height;	/* Minimum frame height [pixel] */
+	uint32_t			max_height;	/* Maximum frame height [pixel] */
+	uint32_t			step_height;	/* Frame height step size [pixel] */
 };
 
 struct v4l2_frmsizeenum {
-	__u32			index;		/* Frame size number */
-	__u32			pixel_format;	/* Pixel format */
-	__u32			type;		/* Frame size type the device supports. */
+	uint32_t			index;		/* Frame size number */
+	uint32_t			pixel_format;	/* Pixel format */
+	uint32_t			type;		/* Frame size type the device supports. */
 
 	union {					/* Frame size */
 		struct v4l2_frmsize_discrete	discrete;
 		struct v4l2_frmsize_stepwise	stepwise;
 	};
 
-	__u32   reserved[2];			/* Reserved space for future use */
+	uint32_t   reserved[2];			/* Reserved space for future use */
 };
 
 /*
@@ -416,18 +416,18 @@ struct v4l2_frmival_stepwise {
 };
 
 struct v4l2_frmivalenum {
-	__u32			index;		/* Frame format index */
-	__u32			pixel_format;	/* Pixel format */
-	__u32			width;		/* Frame width */
-	__u32			height;		/* Frame height */
-	__u32			type;		/* Frame interval type the device supports. */
+	uint32_t			index;		/* Frame format index */
+	uint32_t			pixel_format;	/* Pixel format */
+	uint32_t			width;		/* Frame width */
+	uint32_t			height;		/* Frame height */
+	uint32_t			type;		/* Frame interval type the device supports. */
 
 	union {					/* Frame interval */
 		struct v4l2_fract		discrete;
 		struct v4l2_frmival_stepwise	stepwise;
 	};
 
-	__u32	reserved[2];			/* Reserved space for future use */
+	uint32_t	reserved[2];			/* Reserved space for future use */
 };
 #endif
 
@@ -435,13 +435,13 @@ struct v4l2_frmivalenum {
  *	T I M E C O D E
  */
 struct v4l2_timecode {
-	__u32	type;
-	__u32	flags;
-	__u8	frames;
-	__u8	seconds;
-	__u8	minutes;
-	__u8	hours;
-	__u8	userbits[4];
+	uint32_t	type;
+	uint32_t	flags;
+	uint8_t	frames;
+	uint8_t	seconds;
+	uint8_t	minutes;
+	uint8_t	hours;
+	uint8_t	userbits[4];
 };
 
 /*  Type  */
@@ -470,7 +470,7 @@ struct v4l2_jpegcompression {
 	int  COM_len;           /* Length of data in JPEG COM segment */
 	char COM_data[60];      /* Data in JPEG COM segment */
 
-	__u32 jpeg_markers;     /* Which markers should go into the JPEG
+	uint32_t jpeg_markers;     /* Which markers should go into the JPEG
 				 * output. Unless you exactly know what
 				 * you do, leave them untouched.
 				 * Inluding less markers will make the
@@ -492,31 +492,31 @@ struct v4l2_jpegcompression {
  *	M E M O R Y - M A P P I N G   B U F F E R S
  */
 struct v4l2_requestbuffers {
-	__u32			count;
+	uint32_t			count;
 	enum v4l2_buf_type      type;
 	enum v4l2_memory        memory;
-	__u32			reserved[2];
+	uint32_t			reserved[2];
 };
 
 struct v4l2_buffer {
-	__u32			index;
+	uint32_t			index;
 	enum v4l2_buf_type      type;
-	__u32			bytesused;
-	__u32			flags;
+	uint32_t			bytesused;
+	uint32_t			flags;
 	enum v4l2_field		field;
 	struct timeval		timestamp;
 	struct v4l2_timecode	timecode;
-	__u32			sequence;
+	uint32_t			sequence;
 
 	/* memory location */
 	enum v4l2_memory        memory;
 	union {
-		__u32           offset;
+		uint32_t           offset;
 		unsigned long   userptr;
 	} m;
-	__u32			length;
-	__u32			input;
-	__u32			reserved;
+	uint32_t			length;
+	uint32_t			input;
+	uint32_t			reserved;
 };
 
 /*  Flags for 'flags' field */
@@ -533,8 +533,8 @@ struct v4l2_buffer {
  *	O V E R L A Y   P R E V I E W
  */
 struct v4l2_framebuffer {
-	__u32			capability;
-	__u32			flags;
+	uint32_t			capability;
+	uint32_t			flags;
 /* FIXME: in theory we should pass something like PCI device + memory
  * region + offset instead of some physical address */
 	void                    *base;
@@ -564,23 +564,23 @@ struct v4l2_clip {
 struct v4l2_window {
 	struct v4l2_rect        w;
 	enum v4l2_field  	field;
-	__u32			chromakey;
+	uint32_t			chromakey;
 	struct v4l2_clip	*clips;
-	__u32			clipcount;
+	uint32_t			clipcount;
 	void			*bitmap;
-	__u8                    global_alpha;
+	uint8_t                    global_alpha;
 };
 
 /*
  *	C A P T U R E   P A R A M E T E R S
  */
 struct v4l2_captureparm {
-	__u32		   capability;	  /*  Supported modes */
-	__u32		   capturemode;	  /*  Current mode */
+	uint32_t		   capability;	  /*  Supported modes */
+	uint32_t		   capturemode;	  /*  Current mode */
 	struct v4l2_fract  timeperframe;  /*  Time per frame in .1us units */
-	__u32		   extendedmode;  /*  Driver-specific extensions */
-	__u32              readbuffers;   /*  # of buffers for read */
-	__u32		   reserved[4];
+	uint32_t		   extendedmode;  /*  Driver-specific extensions */
+	uint32_t              readbuffers;   /*  # of buffers for read */
+	uint32_t		   reserved[4];
 };
 
 /*  Flags for 'capability' and 'capturemode' fields */
@@ -588,12 +588,12 @@ struct v4l2_captureparm {
 #define V4L2_CAP_TIMEPERFRAME	0x1000	/*  timeperframe field is supported */
 
 struct v4l2_outputparm {
-	__u32		   capability;	 /*  Supported modes */
-	__u32		   outputmode;	 /*  Current mode */
+	uint32_t		   capability;	 /*  Supported modes */
+	uint32_t		   outputmode;	 /*  Current mode */
 	struct v4l2_fract  timeperframe; /*  Time per frame in seconds */
-	__u32		   extendedmode; /*  Driver-specific extensions */
-	__u32              writebuffers; /*  # of buffers for write */
-	__u32		   reserved[4];
+	uint32_t		   extendedmode; /*  Driver-specific extensions */
+	uint32_t              writebuffers; /*  # of buffers for write */
+	uint32_t		   reserved[4];
 };
 
 /*
@@ -615,7 +615,7 @@ struct v4l2_crop {
  *      A N A L O G   V I D E O   S T A N D A R D
  */
 
-typedef __u64 v4l2_std_id;
+typedef uint64_t v4l2_std_id;
 
 /* one bit for each */
 #define V4L2_STD_PAL_B          ((v4l2_std_id)0x00000001)
@@ -652,7 +652,7 @@ typedef __u64 v4l2_std_id;
 
 /* FIXME:
    Although std_id is 64 bits, there is an issue on PPC32 architecture that
-   makes switch(__u64) to break. So, there's a hack on v4l2-common.c rounding
+   makes switch(uint64_t) to break. So, there's a hack on v4l2-common.c rounding
    this value to 32 bits.
    As, currently, the max value is for V4L2_STD_ATSC_16_VSB (30 bits wide),
    it should work fine. However, if needed to add more than two standards,
@@ -705,26 +705,26 @@ typedef __u64 v4l2_std_id;
 				 V4L2_STD_625_50)
 
 struct v4l2_standard {
-	__u32		     index;
+	uint32_t		     index;
 	v4l2_std_id          id;
-	__u8		     name[24];
+	uint8_t		     name[24];
 	struct v4l2_fract    frameperiod; /* Frames, not fields */
-	__u32		     framelines;
-	__u32		     reserved[4];
+	uint32_t		     framelines;
+	uint32_t		     reserved[4];
 };
 
 /*
  *	V I D E O   I N P U T S
  */
 struct v4l2_input {
-	__u32	     index;		/*  Which input */
-	__u8	     name[32];		/*  Label */
-	__u32	     type;		/*  Type of input */
-	__u32	     audioset;		/*  Associated audios (bitfield) */
-	__u32        tuner;             /*  Associated tuner */
+	uint32_t	     index;		/*  Which input */
+	uint8_t	     name[32];		/*  Label */
+	uint32_t	     type;		/*  Type of input */
+	uint32_t	     audioset;		/*  Associated audios (bitfield) */
+	uint32_t        tuner;             /*  Associated tuner */
 	v4l2_std_id  std;
-	__u32	     status;
-	__u32	     reserved[4];
+	uint32_t	     status;
+	uint32_t	     reserved[4];
 };
 
 /*  Values for the 'type' field */
@@ -759,13 +759,13 @@ struct v4l2_input {
  *	V I D E O   O U T P U T S
  */
 struct v4l2_output {
-	__u32	     index;		/*  Which output */
-	__u8	     name[32];		/*  Label */
-	__u32	     type;		/*  Type of output */
-	__u32	     audioset;		/*  Associated audios (bitfield) */
-	__u32	     modulator;         /*  Associated modulator */
+	uint32_t	     index;		/*  Which output */
+	uint8_t	     name[32];		/*  Label */
+	uint32_t	     type;		/*  Type of output */
+	uint32_t	     audioset;		/*  Associated audios (bitfield) */
+	uint32_t	     modulator;         /*  Associated modulator */
 	v4l2_std_id  std;
-	__u32	     reserved[4];
+	uint32_t	     reserved[4];
 };
 /*  Values for the 'type' field */
 #define V4L2_OUTPUT_TYPE_MODULATOR		1
@@ -776,25 +776,25 @@ struct v4l2_output {
  *	C O N T R O L S
  */
 struct v4l2_control {
-	__u32		     id;
-	__s32		     value;
+	uint32_t		     id;
+	int32_t		     value;
 };
 
 struct v4l2_ext_control {
-	__u32 id;
-	__u32 reserved2[2];
+	uint32_t id;
+	uint32_t reserved2[2];
 	union {
-		__s32 value;
-		__s64 value64;
+		int32_t value;
+		int64_t value64;
 		void *reserved;
 	};
 } __attribute__ ((packed));
 
 struct v4l2_ext_controls {
-	__u32 ctrl_class;
-	__u32 count;
-	__u32 error_idx;
-	__u32 reserved[2];
+	uint32_t ctrl_class;
+	uint32_t count;
+	uint32_t error_idx;
+	uint32_t reserved[2];
 	struct v4l2_ext_control *controls;
 };
 
@@ -809,23 +809,23 @@ struct v4l2_ext_controls {
 
 /*  Used in the VIDIOC_QUERYCTRL ioctl for querying controls */
 struct v4l2_queryctrl {
-	__u32		     id;
+	uint32_t		     id;
 	enum v4l2_ctrl_type  type;
-	__u8		     name[32];	/* Whatever */
-	__s32		     minimum;	/* Note signedness */
-	__s32		     maximum;
-	__s32		     step;
-	__s32		     default_value;
-	__u32                flags;
-	__u32		     reserved[2];
+	uint8_t		     name[32];	/* Whatever */
+	int32_t		     minimum;	/* Note signedness */
+	int32_t		     maximum;
+	int32_t		     step;
+	int32_t		     default_value;
+	uint32_t                flags;
+	uint32_t		     reserved[2];
 };
 
 /*  Used in the VIDIOC_QUERYMENU ioctl for querying menu items */
 struct v4l2_querymenu {
-	__u32		id;
-	__u32		index;
-	__u8		name[32];	/* Whatever */
-	__u32		reserved;
+	uint32_t		id;
+	uint32_t		index;
+	uint8_t		name[32];	/* Whatever */
+	uint32_t		reserved;
 };
 
 /*  Control flags  */
@@ -1145,27 +1145,27 @@ enum  v4l2_exposure_auto_type {
  *	T U N I N G
  */
 struct v4l2_tuner {
-	__u32                   index;
-	__u8			name[32];
+	uint32_t                   index;
+	uint8_t			name[32];
 	enum v4l2_tuner_type    type;
-	__u32			capability;
-	__u32			rangelow;
-	__u32			rangehigh;
-	__u32			rxsubchans;
-	__u32			audmode;
-	__s32			signal;
-	__s32			afc;
-	__u32			reserved[4];
+	uint32_t			capability;
+	uint32_t			rangelow;
+	uint32_t			rangehigh;
+	uint32_t			rxsubchans;
+	uint32_t			audmode;
+	int32_t			signal;
+	int32_t			afc;
+	uint32_t			reserved[4];
 };
 
 struct v4l2_modulator {
-	__u32			index;
-	__u8			name[32];
-	__u32			capability;
-	__u32			rangelow;
-	__u32			rangehigh;
-	__u32			txsubchans;
-	__u32			reserved[4];
+	uint32_t			index;
+	uint8_t			name[32];
+	uint32_t			capability;
+	uint32_t			rangelow;
+	uint32_t			rangehigh;
+	uint32_t			txsubchans;
+	uint32_t			reserved[4];
 };
 
 /*  Flags for the 'capability' field */
@@ -1192,29 +1192,29 @@ struct v4l2_modulator {
 #define V4L2_TUNER_MODE_LANG1_LANG2	0x0004
 
 struct v4l2_frequency {
-	__u32		      tuner;
+	uint32_t		      tuner;
 	enum v4l2_tuner_type  type;
-	__u32		      frequency;
-	__u32		      reserved[8];
+	uint32_t		      frequency;
+	uint32_t		      reserved[8];
 };
 
 struct v4l2_hw_freq_seek {
-	__u32		      tuner;
+	uint32_t		      tuner;
 	enum v4l2_tuner_type  type;
-	__u32		      seek_upward;
-	__u32		      wrap_around;
-	__u32		      reserved[8];
+	uint32_t		      seek_upward;
+	uint32_t		      wrap_around;
+	uint32_t		      reserved[8];
 };
 
 /*
  *	A U D I O
  */
 struct v4l2_audio {
-	__u32	index;
-	__u8	name[32];
-	__u32	capability;
-	__u32	mode;
-	__u32	reserved[2];
+	uint32_t	index;
+	uint8_t	name[32];
+	uint32_t	capability;
+	uint32_t	mode;
+	uint32_t	reserved[2];
 };
 
 /*  Flags for the 'capability' field */
@@ -1225,11 +1225,11 @@ struct v4l2_audio {
 #define V4L2_AUDMODE_AVL		0x00001
 
 struct v4l2_audioout {
-	__u32	index;
-	__u8	name[32];
-	__u32	capability;
-	__u32	mode;
-	__u32	reserved[2];
+	uint32_t	index;
+	uint8_t	name[32];
+	uint32_t	capability;
+	uint32_t	mode;
+	uint32_t	reserved[2];
 };
 
 /*
@@ -1244,18 +1244,18 @@ struct v4l2_audioout {
 #define V4L2_ENC_IDX_FRAME_MASK (0xf)
 
 struct v4l2_enc_idx_entry {
-	__u64 offset;
-	__u64 pts;
-	__u32 length;
-	__u32 flags;
-	__u32 reserved[2];
+	uint64_t offset;
+	uint64_t pts;
+	uint32_t length;
+	uint32_t flags;
+	uint32_t reserved[2];
 };
 
 #define V4L2_ENC_IDX_ENTRIES (64)
 struct v4l2_enc_idx {
-	__u32 entries;
-	__u32 entries_cap;
-	__u32 reserved[4];
+	uint32_t entries;
+	uint32_t entries_cap;
+	uint32_t reserved[4];
 	struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
 };
 
@@ -1269,11 +1269,11 @@ struct v4l2_enc_idx {
 #define V4L2_ENC_CMD_STOP_AT_GOP_END    (1 << 0)
 
 struct v4l2_encoder_cmd {
-	__u32 cmd;
-	__u32 flags;
+	uint32_t cmd;
+	uint32_t flags;
 	union {
 		struct {
-			__u32 data[8];
+			uint32_t data[8];
 		} raw;
 	};
 };
@@ -1289,14 +1289,14 @@ struct v4l2_encoder_cmd {
 
 /* Raw VBI */
 struct v4l2_vbi_format {
-	__u32	sampling_rate;		/* in 1 Hz */
-	__u32	offset;
-	__u32	samples_per_line;
-	__u32	sample_format;		/* V4L2_PIX_FMT_* */
-	__s32	start[2];
-	__u32	count[2];
-	__u32	flags;			/* V4L2_VBI_* */
-	__u32	reserved[2];		/* must be zero */
+	uint32_t	sampling_rate;		/* in 1 Hz */
+	uint32_t	offset;
+	uint32_t	samples_per_line;
+	uint32_t	sample_format;		/* V4L2_PIX_FMT_* */
+	int32_t	start[2];
+	uint32_t	count[2];
+	uint32_t	flags;			/* V4L2_VBI_* */
+	uint32_t	reserved[2];		/* must be zero */
 };
 
 /*  VBI flags  */
@@ -1311,14 +1311,14 @@ struct v4l2_vbi_format {
  */
 
 struct v4l2_sliced_vbi_format {
-	__u16   service_set;
+	uint16_t   service_set;
 	/* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
 	   service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
 				 (equals frame lines 313-336 for 625 line video
 				  standards, 263-286 for 525 line standards) */
-	__u16   service_lines[2][24];
-	__u32   io_size;
-	__u32   reserved[2];            /* must be zero */
+	uint16_t   service_lines[2][24];
+	uint32_t   io_size;
+	uint32_t   reserved[2];            /* must be zero */
 };
 
 /* Teletext World System Teletext
@@ -1335,22 +1335,22 @@ struct v4l2_sliced_vbi_format {
 #define V4L2_SLICED_VBI_625             (V4L2_SLICED_TELETEXT_B | V4L2_SLICED_VPS | V4L2_SLICED_WSS_625)
 
 struct v4l2_sliced_vbi_cap {
-	__u16   service_set;
+	uint16_t   service_set;
 	/* service_lines[0][...] specifies lines 0-23 (1-23 used) of the first field
 	   service_lines[1][...] specifies lines 0-23 (1-23 used) of the second field
 				 (equals frame lines 313-336 for 625 line video
 				  standards, 263-286 for 525 line standards) */
-	__u16   service_lines[2][24];
+	uint16_t   service_lines[2][24];
 	enum v4l2_buf_type type;
-	__u32   reserved[3];    /* must be 0 */
+	uint32_t   reserved[3];    /* must be 0 */
 };
 
 struct v4l2_sliced_vbi_data {
-	__u32   id;
-	__u32   field;          /* 0: first field, 1: second field */
-	__u32   line;           /* 1-23 */
-	__u32   reserved;       /* must be 0 */
-	__u8    data[48];
+	uint32_t   id;
+	uint32_t   field;          /* 0: first field, 1: second field */
+	uint32_t   line;           /* 1-23 */
+	uint32_t   reserved;       /* must be 0 */
+	uint8_t    data[48];
 };
 
 /*
@@ -1376,12 +1376,12 @@ struct v4l2_sliced_vbi_data {
 #define V4L2_MPEG_VBI_IVTV_VPS            (7)
 
 struct v4l2_mpeg_vbi_itv0_line {
-	__u8 id;	/* One of V4L2_MPEG_VBI_IVTV_* above */
-	__u8 data[42];	/* Sliced VBI data for the line */
+	uint8_t id;	/* One of V4L2_MPEG_VBI_IVTV_* above */
+	uint8_t data[42];	/* Sliced VBI data for the line */
 } __attribute__ ((packed));
 
 struct v4l2_mpeg_vbi_itv0 {
-	__le32 linemask[2]; /* Bitmasks of VBI service lines present */
+	uint32_t linemask[2]; /* Bitmasks of VBI service lines present */
 	struct v4l2_mpeg_vbi_itv0_line line[35];
 } __attribute__ ((packed));
 
@@ -1393,7 +1393,7 @@ struct v4l2_mpeg_vbi_ITV0 {
 #define V4L2_MPEG_VBI_IVTV_MAGIC1	"ITV0"
 
 struct v4l2_mpeg_vbi_fmt_ivtv {
-	__u8 magic[4];
+	uint8_t magic[4];
 	union {
 		struct v4l2_mpeg_vbi_itv0 itv0;
 		struct v4l2_mpeg_vbi_ITV0 ITV0;
@@ -1413,7 +1413,7 @@ struct v4l2_format {
 		struct v4l2_window		win;     /* V4L2_BUF_TYPE_VIDEO_OVERLAY */
 		struct v4l2_vbi_format		vbi;     /* V4L2_BUF_TYPE_VBI_CAPTURE */
 		struct v4l2_sliced_vbi_format	sliced;  /* V4L2_BUF_TYPE_SLICED_VBI_CAPTURE */
-		__u8	raw_data[200];                   /* user-defined */
+		uint8_t	raw_data[200];                   /* user-defined */
 	} fmt;
 };
 
@@ -1425,7 +1425,7 @@ struct v4l2_streamparm {
 	union {
 		struct v4l2_captureparm	capture;
 		struct v4l2_outputparm	output;
-		__u8	raw_data[200];  /* user-defined */
+		uint8_t	raw_data[200];  /* user-defined */
 	} parm;
 };
 
@@ -1444,25 +1444,25 @@ struct v4l2_streamparm {
 #define V4L2_CHIP_MATCH_AC97       3  /* Match against anciliary AC97 chip */
 
 struct v4l2_dbg_match {
-	__u32 type; /* Match type */
+	uint32_t type; /* Match type */
 	union {     /* Match this chip, meaning determined by type */
-		__u32 addr;
+		uint32_t addr;
 		char name[32];
 	};
 } __attribute__ ((packed));
 
 struct v4l2_dbg_register {
 	struct v4l2_dbg_match match;
-	__u32 size;	/* register size in bytes */
-	__u64 reg;
-	__u64 val;
+	uint32_t size;	/* register size in bytes */
+	uint64_t reg;
+	uint64_t val;
 } __attribute__ ((packed));
 
 /* VIDIOC_DBG_G_CHIP_IDENT */
 struct v4l2_dbg_chip_ident {
 	struct v4l2_dbg_match match;
-	__u32 ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
-	__u32 revision;    /* chip revision, chip specific */
+	uint32_t ident;       /* chip identifier as specified in <media/v4l2-chip-ident.h> */
+	uint32_t revision;    /* chip revision, chip specific */
 } __attribute__ ((packed));
 
 /*
